Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.


↳ QTRS
  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

MATCH_2(x, l', a_4, l_3, Pair(l1, l2)) → TEST(a_4, x)
MATCH_4(l_5, Cons(a, l')) → PART(a, l')
APPEND(l1_2, l2_1) → MATCH_0(l1_2, l2_1, l1_2)
MATCH_1(a_4, l_3, Cons(x, l')) → PART(a_4, l')
MATCH_5(a, l', l_5, Pair(l1, l2)) → APPEND(quick(l1), Cons(a, quick(l2)))
MATCH_5(a, l', l_5, Pair(l1, l2)) → QUICK(l1)
QUICK(l_5) → MATCH_4(l_5, l_5)
MATCH_4(l_5, Cons(a, l')) → MATCH_5(a, l', l_5, part(a, l'))
MATCH_0(l1_2, l2_1, Cons(x, l)) → APPEND(l, l2_1)
MATCH_2(x, l', a_4, l_3, Pair(l1, l2)) → MATCH_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
MATCH_1(a_4, l_3, Cons(x, l')) → MATCH_2(x, l', a_4, l_3, part(a_4, l'))
PART(a_4, l_3) → MATCH_1(a_4, l_3, l_3)
MATCH_5(a, l', l_5, Pair(l1, l2)) → QUICK(l2)

The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ EdgeDeletionProof

Q DP problem:
The TRS P consists of the following rules:

MATCH_2(x, l', a_4, l_3, Pair(l1, l2)) → TEST(a_4, x)
MATCH_4(l_5, Cons(a, l')) → PART(a, l')
APPEND(l1_2, l2_1) → MATCH_0(l1_2, l2_1, l1_2)
MATCH_1(a_4, l_3, Cons(x, l')) → PART(a_4, l')
MATCH_5(a, l', l_5, Pair(l1, l2)) → APPEND(quick(l1), Cons(a, quick(l2)))
MATCH_5(a, l', l_5, Pair(l1, l2)) → QUICK(l1)
QUICK(l_5) → MATCH_4(l_5, l_5)
MATCH_4(l_5, Cons(a, l')) → MATCH_5(a, l', l_5, part(a, l'))
MATCH_0(l1_2, l2_1, Cons(x, l)) → APPEND(l, l2_1)
MATCH_2(x, l', a_4, l_3, Pair(l1, l2)) → MATCH_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
MATCH_1(a_4, l_3, Cons(x, l')) → MATCH_2(x, l', a_4, l_3, part(a_4, l'))
PART(a_4, l_3) → MATCH_1(a_4, l_3, l_3)
MATCH_5(a, l', l_5, Pair(l1, l2)) → QUICK(l2)

The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We deleted some edges using various graph approximations

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ EdgeDeletionProof
        ↳ QDP
          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

MATCH_2(x, l', a_4, l_3, Pair(l1, l2)) → TEST(a_4, x)
MATCH_4(l_5, Cons(a, l')) → PART(a, l')
APPEND(l1_2, l2_1) → MATCH_0(l1_2, l2_1, l1_2)
MATCH_1(a_4, l_3, Cons(x, l')) → PART(a_4, l')
MATCH_5(a, l', l_5, Pair(l1, l2)) → QUICK(l1)
MATCH_5(a, l', l_5, Pair(l1, l2)) → APPEND(quick(l1), Cons(a, quick(l2)))
MATCH_4(l_5, Cons(a, l')) → MATCH_5(a, l', l_5, part(a, l'))
QUICK(l_5) → MATCH_4(l_5, l_5)
MATCH_0(l1_2, l2_1, Cons(x, l)) → APPEND(l, l2_1)
MATCH_2(x, l', a_4, l_3, Pair(l1, l2)) → MATCH_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
MATCH_1(a_4, l_3, Cons(x, l')) → MATCH_2(x, l', a_4, l_3, part(a_4, l'))
PART(a_4, l_3) → MATCH_1(a_4, l_3, l_3)
MATCH_5(a, l', l_5, Pair(l1, l2)) → QUICK(l2)

The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 3 SCCs with 5 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ EdgeDeletionProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ QDPOrderProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PART(a_4, l_3) → MATCH_1(a_4, l_3, l_3)
MATCH_1(a_4, l_3, Cons(x, l')) → PART(a_4, l')

The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


MATCH_1(a_4, l_3, Cons(x, l')) → PART(a_4, l')
The remaining pairs can at least be oriented weakly.

PART(a_4, l_3) → MATCH_1(a_4, l_3, l_3)
Used ordering: Combined order from the following AFS and order.
PART(x1, x2)  =  x2
MATCH_1(x1, x2, x3)  =  x3
Cons(x1, x2)  =  Cons(x2)

Lexicographic path order with status [19].
Quasi-Precedence:
trivial

Status:
trivial


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ EdgeDeletionProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ QDPOrderProof
                  ↳ QDP
                    ↳ DependencyGraphProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PART(a_4, l_3) → MATCH_1(a_4, l_3, l_3)

The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ EdgeDeletionProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ QDPOrderProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MATCH_0(l1_2, l2_1, Cons(x, l)) → APPEND(l, l2_1)
APPEND(l1_2, l2_1) → MATCH_0(l1_2, l2_1, l1_2)

The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


MATCH_0(l1_2, l2_1, Cons(x, l)) → APPEND(l, l2_1)
The remaining pairs can at least be oriented weakly.

APPEND(l1_2, l2_1) → MATCH_0(l1_2, l2_1, l1_2)
Used ordering: Combined order from the following AFS and order.
MATCH_0(x1, x2, x3)  =  x3
Cons(x1, x2)  =  Cons(x2)
APPEND(x1, x2)  =  x1

Lexicographic path order with status [19].
Quasi-Precedence:
trivial

Status:
trivial


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ EdgeDeletionProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ QDPOrderProof
                  ↳ QDP
                    ↳ DependencyGraphProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

APPEND(l1_2, l2_1) → MATCH_0(l1_2, l2_1, l1_2)

The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 1 less node.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ EdgeDeletionProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MATCH_4(l_5, Cons(a, l')) → MATCH_5(a, l', l_5, part(a, l'))
QUICK(l_5) → MATCH_4(l_5, l_5)
MATCH_5(a, l', l_5, Pair(l1, l2)) → QUICK(l2)
MATCH_5(a, l', l_5, Pair(l1, l2)) → QUICK(l1)

The TRS R consists of the following rules:

test(x_0, y) → True
test(x_0, y) → False
append(l1_2, l2_1) → match_0(l1_2, l2_1, l1_2)
match_0(l1_2, l2_1, Nil) → l2_1
match_0(l1_2, l2_1, Cons(x, l)) → Cons(x, append(l, l2_1))
part(a_4, l_3) → match_1(a_4, l_3, l_3)
match_1(a_4, l_3, Nil) → Pair(Nil, Nil)
match_1(a_4, l_3, Cons(x, l')) → match_2(x, l', a_4, l_3, part(a_4, l'))
match_2(x, l', a_4, l_3, Pair(l1, l2)) → match_3(l1, l2, x, l', a_4, l_3, test(a_4, x))
match_3(l1, l2, x, l', a_4, l_3, False) → Pair(Cons(x, l1), l2)
match_3(l1, l2, x, l', a_4, l_3, True) → Pair(l1, Cons(x, l2))
quick(l_5) → match_4(l_5, l_5)
match_4(l_5, Nil) → Nil
match_4(l_5, Cons(a, l')) → match_5(a, l', l_5, part(a, l'))
match_5(a, l', l_5, Pair(l1, l2)) → append(quick(l1), Cons(a, quick(l2)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.